package cn.com.ebidding.business.service.impl;

import cn.com.ebidding.business.entity.Type;
import cn.com.ebidding.business.service.BizTypeService;
import cn.com.ebidding.business.util.JsonUtils;
import cn.com.ebidding.business.vo.TypeConditionVO;
import cn.com.ebidding.persistence.beans.BizType;
import cn.com.ebidding.persistence.mapper.BizTypeMapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 分类
 *
 * @author 扫地僧 (saods@ebidding.com.cn)
 * @version 1.0
 * @website https://ksp.ebidding.com.cn
 * @date 2018/4/16 16:26
 * @since 1.0
 */
@Service
public class BizTypeServiceImpl implements BizTypeService {

    @Autowired
    private BizTypeMapper bizTypeMapper;

    @Override
    public PageInfo<Type> findPageBreakByCondition(TypeConditionVO vo) {
        PageHelper.startPage(vo.getPageNumber(), vo.getPageSize());
        List<BizType> list = bizTypeMapper.findPageBreakByCondition(vo);
        List<Type> boList = getTypes(list);
        if (boList == null) return null;
        PageInfo bean = new PageInfo<BizType>(list);
        bean.setList(boList);
        return bean;
    }

    @Override
    public List<Type> listParent() {
        List<BizType> list = bizTypeMapper.listParent();
        return getTypes(list);
    }
    //新添加的方法
    @Override
    public String listParents(){
        List<BizType> entityList = bizTypeMapper.listAllTypes();
        //父节点最多到2级
        return JsonUtils.toJSon(findTree(entityList,2));
    }


    @Override
    public List<Type> listTypeForMenu() {
        /*TypeConditionVO vo = new TypeConditionVO();
        vo.setPageNumber(1);
        vo.setPageSize(100);
        PageHelper.startPage(vo.getPageNumber(), vo.getPageSize());
        List<BizType> entityList = bizTypeMapper.listTypeForMenu();*/

        List<BizType> entityList = findTree( bizTypeMapper.listAllTypes(),3);
        return getTypes(entityList);
    }

    //新添加的方法
    @Override
    public  String listTypeForJson(){
        List<BizType> entityList = bizTypeMapper.listAllTypes();
        String json = JsonUtils.toJSon(findTree(entityList,3));
        return json;
    }

    /**
     * @param allMenu
     * @param level 菜单层级
     * @return
     */
    public  List<BizType> findTree(List<BizType> allMenu,int level){

        if(null == allMenu)
            return  new ArrayList<>();
        //根节点
        List<BizType> rootMenu = new ArrayList<BizType>();
        for (BizType nav : allMenu) {
            if (null == nav.getPid() || "".equals(nav.getPid())) {//父节点为空的，为根节点。
                rootMenu.add(nav);
            }
        }
         /* 根据Menu类的order排序 */
        Collections.sort(rootMenu, order());

        //为根菜单设置子菜单，getClild是递归调用的
        for (BizType nav : rootMenu) {
        /* 获取根节点下的所有子节点 使用getChild方法*/
            List<BizType> childList = getChild(nav.getId(), allMenu,level);
            nav.setNodes(childList);//给根节点设置子节点
        }

        return  rootMenu;
    }

    /**
     * 获取子节点
     * @param id 父节点id
     * @param allMenu 所有菜单列表
     * @param level 层级
     * @return 每个根节点下，所有子菜单列表
     */
    public List<BizType> getChild(Long id,List<BizType> allMenu,int level){
        if(level <2){
            return new ArrayList<BizType>();
        }
        //子菜单
        List<BizType> childList = new ArrayList<BizType>();
        for (BizType nav : allMenu) {
            // 遍历所有节点，将所有菜单的父id与传过来的根节点的id比较
            //相等说明：为该根节点的子节点。
            if(null != nav.getPid() && nav.getPid().equals(id)){
                childList.add(nav);
            }
        }
        //递归
        for (BizType nav : childList) {
            nav.setNodes(getChild(nav.getId(), allMenu,level - 1));
        }
        Collections.sort(childList,order());//排序
        //如果节点下没有子节点，返回一个空List（递归退出）
        if(childList.size() == 0){
            return new ArrayList<BizType>();
        }
        return childList;
    }

    /*
  * 排序,根据sort排序
  */
    public Comparator<BizType> order(){
        Comparator<BizType> comparator = new Comparator<BizType>() {
            @Override
            public int compare(BizType o1, BizType o2) {
                if(null == o1.getSort()){
                    o1.setSort(0);
                }
                if(null == o2.getSort()){
                    o2.setSort(0);
                }
                if(o1.getSort() != o2.getSort()){
                    return o1.getSort() - o2.getSort();
                }
                return 0;
            }
        };
        return comparator;
    }


    private List<Type> getTypes(List<BizType> list) {
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }
        List<Type> boList = new ArrayList<>();
        for (BizType bizType : list) {
            boList.add(new Type(bizType));
        }
        return boList;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Type insert(Type entity) {
        Assert.notNull(entity, "Type不可为空！");
        entity.setUpdateTime(new Date());
        entity.setCreateTime(new Date());
        bizTypeMapper.insertSelective(entity.getBizType());
        return entity;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean removeByPrimaryKey(Long primaryKey) {
        return bizTypeMapper.deleteByPrimaryKey(primaryKey) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateSelective(Type entity) {
        Assert.notNull(entity, "Type不可为空！");
        entity.setUpdateTime(new Date());
        return bizTypeMapper.updateByPrimaryKeySelective(entity.getBizType()) > 0;
    }

    @Override
    public Type getByPrimaryKey(Long primaryKey) {
        Assert.notNull(primaryKey, "PrimaryKey不可为空！");
        BizType entity = bizTypeMapper.selectByPrimaryKey(primaryKey);
        return null == entity ? null : new Type(entity);
    }

    @Override
    public List<Type> listAll() {
        TypeConditionVO vo = new TypeConditionVO();
        vo.setPageNumber(1);
        vo.setPageSize(100);
        PageHelper.startPage(vo.getPageNumber(), vo.getPageSize());
        List<BizType> entityList = bizTypeMapper.selectAll();

        List<Type> list = getTypes(entityList);
        if (list == null) return null;
        return list;
    }
}
